{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-11-16 16:05:28.212723: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-11-16 16:05:28.282391: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-11-16 16:05:28.282997: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX512F FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-11-16 16:05:29.676520: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
      "/home/dell/anaconda3/envs/CX/lib/python3.8/site-packages/scipy/__init__.py:146: UserWarning: A NumPy version >=1.16.5 and <1.23.0 is required for this version of SciPy (detected version 1.24.3\n",
      "  warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion}\"\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import gym\n",
    "import imageio\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.animation import FuncAnimation\n",
    "from tqdm.notebook import tqdm as tool_bar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_dir(directory):\n",
    "    if not os.path.exists(directory):\n",
    "        os.mkdir(directory)\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Experience_Buffer():\n",
    "    def __init__(self,dimension_state,dimension_action,dimension_reward,buffer_capacity=100000,batch_size=64):\n",
    "        self.dimension_state = dimension_state\n",
    "        self.dimension_action = dimension_action\n",
    "        self.dimension_reward = dimension_reward\n",
    "        self.buffer_capacity = buffer_capacity\n",
    "        self.batch_size = batch_size\n",
    "        self.buffer_counter = 0\n",
    "        self.buffer_state = np.zeros((self.buffer_capacity,self.dimension_state),dtype='float32')\n",
    "        self.buffer_action = np.zeros((self.buffer_capacity,self.dimension_action),dtype='float32')\n",
    "        self.buffer_reward = np.zeros((self.buffer_capacity,self.dimension_reward),dtype='float32')\n",
    "        self.buffer_state_next = np.zeros((self.buffer_capacity,self.dimension_state),dtype='float32')\n",
    "        self.buffer_done = np.zeros((self.buffer_capacity,1),dtype='float32')\n",
    "        self.buffer_step = np.zeros((self.buffer_capacity,),dtype='float32')\n",
    "    def record(self,x):\n",
    "        index = self.buffer_counter%self.buffer_capacity\n",
    "        self.buffer_state[index] = x[0]\n",
    "        self.buffer_action[index] = x[1]\n",
    "        self.buffer_reward[index] = x[2]\n",
    "        self.buffer_state_next[index] = x[3]\n",
    "        self.buffer_done[index] = x[4]\n",
    "        self.buffer_step[index] = x[5]\n",
    "        self.buffer_counter += 1\n",
    "    def generate_tranining_batch(self,mode=0):\n",
    "        record_range = min(self.buffer_counter,self.buffer_capacity)\n",
    "        if record_range<self.batch_size:\n",
    "            return []\n",
    "        batch_indices = np.random.choice(record_range,self.batch_size)#,p=self.buffer_step[:record_range]*2/np.sum(self.buffer_step[:record_range]*2))\n",
    "        batch_state = tf.convert_to_tensor(self.buffer_state[batch_indices])\n",
    "        batch_action = tf.convert_to_tensor(self.buffer_action[batch_indices])\n",
    "        batch_reward = tf.convert_to_tensor(self.buffer_reward[batch_indices])\n",
    "        batch_state_next = tf.convert_to_tensor(self.buffer_state_next[batch_indices])\n",
    "        batch_done = tf.convert_to_tensor(self.buffer_done[batch_indices])\n",
    "        return [batch_state,batch_action,batch_reward,batch_state_next,batch_done]\n",
    "class Actor_Model(tf.keras.Model):\n",
    "    def __init__(self,dimension_state,dimension_action,layer_dimension=[256,512],action_value_scale=1.0):\n",
    "        super(Actor_Model,self).__init__()\n",
    "        self.dimension_state = dimension_state\n",
    "        self.dimension_action = dimension_action\n",
    "        self.layer = []\n",
    "        for i in layer_dimension:\n",
    "            self.layer.append(tf.keras.layers.BatchNormalization())\n",
    "            self.layer.append(tf.keras.layers.Dense(i,activation='relu'))\n",
    "        self.layer.append(tf.keras.layers.BatchNormalization())\n",
    "        self.layer.append(tf.keras.layers.Dense(self.dimension_action,activation='tanh'))\n",
    "        self.action_value_scale = action_value_scale\n",
    "    def call(self,state):\n",
    "        y = state*1\n",
    "        for i in self.layer:\n",
    "            y = i(y)\n",
    "        return y*self.action_value_scale\n",
    "class Critic_Model(tf.keras.Model):\n",
    "    def __init__(self,dimension_state,dimension_action,dimension_reward,layer_dimension=[256,512]):\n",
    "        super(Critic_Model,self).__init__()\n",
    "        self.dimension_state = dimension_state\n",
    "        self.dimension_action = dimension_action\n",
    "        self.dimension_reward = dimension_reward\n",
    "        self.layer = []\n",
    "        for i in layer_dimension:\n",
    "            self.layer.append(tf.keras.layers.BatchNormalization())\n",
    "            self.layer.append(tf.keras.layers.Dense(i,activation='relu'))\n",
    "        self.layer.append(tf.keras.layers.BatchNormalization())\n",
    "        self.layer.append(tf.keras.layers.Dense(self.dimension_reward,activation='linear'))\n",
    "    def call(self,x):\n",
    "        y = tf.concat(x,axis=1)\n",
    "        for i in self.layer:\n",
    "            y = i(y)\n",
    "        return y\n",
    "class Agent():\n",
    "    def __init__(self,environment_name,learning_rate_Actor_Model=0.001,learning_rate_Critic_Model=0.003,learning_rate_target_transition=0.005,reward_discount=0.99,save_path='./'):\n",
    "        self.environment_name = environment_name\n",
    "        self.environment = gym.make(self.environment_name) \n",
    "        self.dimension_state = self.environment.observation_space.shape[0]\n",
    "        self.dimension_action = self.environment.action_space.shape[0]\n",
    "        self.dimension_reward = 4\n",
    "        self.action_value_bound = np.array([self.environment.action_space.low[0],self.environment.action_space.high[0]])\n",
    "        self.action_value_scale = np.max(abs(self.action_value_bound))\n",
    "        self.explore_value_scale = self.action_value_scale/2\n",
    "        self.save_path = save_path\n",
    "        create_dir(self.save_path)\n",
    "        self.instance_Actor_Model = Actor_Model(self.dimension_state,self.dimension_action,layer_dimension=[256,128],action_value_scale=self.action_value_scale)\n",
    "        self.instance_Critic_Model = Critic_Model(self.dimension_state,self.dimension_action,self.dimension_reward,layer_dimension=[512,256,128])\n",
    "        self.instance_target_Actor_Model = Actor_Model(self.dimension_state,self.dimension_action,layer_dimension=[256,128],action_value_scale=self.action_value_scale)\n",
    "        self.instance_target_Critic_Model = Critic_Model(self.dimension_state,self.dimension_action,self.dimension_reward,layer_dimension=[512,256,128])\n",
    "        self.instance_target_Actor_Model.set_weights(self.instance_Actor_Model.get_weights())\n",
    "        self.instance_target_Critic_Model.set_weights(self.instance_Critic_Model.get_weights())\n",
    "        self.learning_rate_Actor_Model = learning_rate_Actor_Model\n",
    "        self.learning_rate_Critic_Model = learning_rate_Critic_Model\n",
    "        self.instance_Actor_Model.compile(optimizer=tf.keras.optimizers.Adam(self.learning_rate_Actor_Model))#,momentum=0.9))\n",
    "        self.instance_Critic_Model.compile(optimizer=tf.keras.optimizers.Adam(self.learning_rate_Critic_Model))#,momentum=0.9))\n",
    "        self.instance_target_Actor_Model.compile(optimizer=tf.keras.optimizers.Adam(self.learning_rate_Actor_Model))#,momentum=0.9))\n",
    "        self.instance_target_Critic_Model.compile(optimizer=tf.keras.optimizers.Adam(self.learning_rate_Critic_Model))#,momentum=0.9))\n",
    "        _ = self.instance_Actor_Model(tf.random.normal(shape=[1,self.dimension_state]))\n",
    "        _ = self.instance_Critic_Model([tf.random.normal(shape=[1,self.dimension_state]),tf.random.normal(shape=[1,self.dimension_action])])\n",
    "        _ = self.instance_target_Actor_Model(tf.random.normal(shape=[1,self.dimension_state]))\n",
    "        _ = self.instance_target_Critic_Model([tf.random.normal(shape=[1,self.dimension_state]),tf.random.normal(shape=[1,self.dimension_action])])\n",
    "        self.instance_Experience_Buffer = Experience_Buffer(self.dimension_state,self.dimension_action,self.dimension_reward)\n",
    "        self.learning_rate_target_transition = learning_rate_target_transition\n",
    "        self.reward_discount = reward_discount\n",
    "        self.history_episodic_reward = []\n",
    "        self.history_average_reward = []\n",
    "        self.history_best_episodic_reward = -100000.0\n",
    "        self.history_training = [[],[]]\n",
    "        self.force_explore = False\n",
    "        self.reward_weight = np.array([0.001,1,0.1,0.01])\n",
    "    def update_target_model(self,mode=0):\n",
    "        if mode==0:\n",
    "            for (a,b) in zip(self.instance_target_Actor_Model.variables,self.instance_Actor_Model.variables):\n",
    "                a.assign(b*self.learning_rate_target_transition+a*(1-self.learning_rate_target_transition))\n",
    "        else:\n",
    "            for (a,b) in zip(self.instance_target_Critic_Model.variables,self.instance_Critic_Model.variables):\n",
    "                a.assign(b*self.learning_rate_target_transition+a*(1-self.learning_rate_target_transition))\n",
    "    def learn(self):\n",
    "        experience = self.instance_Experience_Buffer.generate_tranining_batch()\n",
    "        if len(experience)==0:\n",
    "            return\n",
    "        for i in range(1):\n",
    "            with tf.GradientTape() as tape:\n",
    "                target_action = self.instance_target_Actor_Model(experience[3])\n",
    "                #target_reward = experience[2]+tf.squeeze(self.reward_discount*self.instance_target_Critic_Model([experience[3],target_action]))*(1-experience[4])-experience[4]*10\n",
    "                target_reward = experience[2]+tf.squeeze(self.reward_discount*self.instance_target_Critic_Model([experience[3],target_action]))*(1-experience[4])\n",
    "                #target_reward = target_reward*0-1 if tf.reduce_sum(tf.where(tf.abs(experience[1])>self.action_value_scale,1.0,0.0)) else target_reward\n",
    "                prediction_reward = tf.squeeze(self.instance_Critic_Model([experience[0],experience[1]]))\n",
    "                loss_critic = tf.math.reduce_mean(tf.math.square(target_reward-prediction_reward))\n",
    "            grad_critic = tape.gradient(loss_critic,self.instance_Critic_Model.trainable_variables)\n",
    "            self.instance_Critic_Model.optimizer.apply_gradients(zip(grad_critic,self.instance_Critic_Model.trainable_variables))\n",
    "        self.update_target_model(1)\n",
    "        self.history_training[1].append(loss_critic)\n",
    "        self.history_training[1] = self.history_training[1][-10000:]\n",
    "        with tf.GradientTape() as tape:\n",
    "            action = self.instance_Actor_Model(experience[0])\n",
    "            prediction_reward = tf.squeeze(self.instance_Critic_Model([experience[0],action]))\n",
    "            loss_actor = tf.reduce_mean(-prediction_reward)#tf.math.reduce_mean(tf.math.square(1-prediction_reward))#-tf.math.reduce_mean(prediction_reward)+0.025*tf.reduce_mean(tf.math.square(action)*tf.where(tf.math.square(action)>self.action_value_scale**2*0.8,1.0,0.0))\n",
    "        grad_actor = tape.gradient(loss_actor,self.instance_Actor_Model.trainable_variables)\n",
    "        self.instance_Actor_Model.optimizer.apply_gradients(zip(grad_actor,self.instance_Actor_Model.trainable_variables))\n",
    "        self.history_training[0].append(loss_actor)\n",
    "        self.history_training[0] = self.history_training[0][-10000:]\n",
    "        self.update_target_model(0)\n",
    "    def explore(self,epoch=5000):\n",
    "        for epoch_counter in tool_bar(range(epoch)):\n",
    "            state = self.environment.reset()\n",
    "            episodic_reward = 0\n",
    "            tmp_rate = 0.25\n",
    "            step = 1\n",
    "            while True:\n",
    "                state = tf.expand_dims(tf.convert_to_tensor(state),0)\n",
    "                if self.force_explore:\n",
    "                    action = self.environment.action_space.sample()\n",
    "                else:\n",
    "                    if 0:\n",
    "                        action = tf.squeeze(self.instance_Actor_Model(state))*0.8+tf.random.normal(shape=[self.dimension_action],mean=0,stddev=0.1)*self.explore_value_scale\n",
    "                        action = tf.clip_by_value(action,self.action_value_bound[0],self.action_value_bound[1])\n",
    "                    else:\n",
    "                        action = 0.5*tf.squeeze(self.instance_Actor_Model(state))+0.5*self.environment.action_space.sample()\n",
    "                state_next,reward,done,info = self.environment.step(action)\n",
    "                #reward = info['reward_linvel']+info['reward_quadctrl']+info['reward_impact']0.0005*info['reward_alive']\n",
    "                #reward *= (1-done)\n",
    "                #reward /= 100\n",
    "                episodic_reward += reward\n",
    "                self.instance_Experience_Buffer.record([state,action,self.reward_weight*np.array([info['reward_alive'],info['reward_linvel'],info['reward_quadctrl'],info['reward_impact']]),state_next,done,step])\n",
    "                self.learn()\n",
    "                state = state_next\n",
    "                step += 1\n",
    "                if done:\n",
    "                    break\n",
    "            for i in range(0):\n",
    "                self.learn()\n",
    "            self.history_episodic_reward.append(episodic_reward)\n",
    "            self.history_average_reward.append(np.mean(self.history_episodic_reward[-25:]))\n",
    "            if episodic_reward>self.history_best_episodic_reward:\n",
    "                print('Found a new best solution with reward '+str(episodic_reward))\n",
    "                self.save_model()\n",
    "                self.history_best_episodic_reward = episodic_reward\n",
    "    def test(self):\n",
    "        video = []\n",
    "        state = self.environment.reset()\n",
    "        episodic_reward = 0\n",
    "        while True:\n",
    "            state = tf.expand_dims(tf.convert_to_tensor(state),0)\n",
    "            action = tf.squeeze(self.instance_Actor_Model.predict(state))\n",
    "            action = tf.clip_by_value(action,self.action_value_bound[0],self.action_value_bound[1])\n",
    "            state_next,reward,done,info = self.environment.step(action)\n",
    "            video.append(self.environment.render(mode ='rgb_array'))\n",
    "            episodic_reward += reward\n",
    "            state = state_next\n",
    "            if done:\n",
    "                break\n",
    "        writer = imageio.get_writer(self.save_path+'test_video.mp4',fps=30) \n",
    "        for image in video:\n",
    "            writer.append_data(np.uint8(image))\n",
    "        writer.close()\n",
    "        print('Video saved to '+self.save_path+'test_video.mp4.')\n",
    "        return episodic_reward\n",
    "    def save_model(self):\n",
    "        self.instance_Actor_Model.save_weights(self.save_path+'actor_model.h5')\n",
    "        self.instance_Critic_Model.save_weights(self.save_path+'critic_model.h5')\n",
    "        self.instance_target_Actor_Model.save_weights(self.save_path+'target_actor_model.h5')\n",
    "        self.instance_target_Critic_Model.save_weights(self.save_path+'target_critic_model.h5')\n",
    "    def load_model(self):\n",
    "        self.instance_Actor_Model.load_weights(self.save_path+'actor_model.h5')\n",
    "        self.instance_Critic_Model.load_weights(self.save_path+'critic_model.h5')\n",
    "        self.instance_target_Actor_Model.load_weights(self.save_path+'target_actor_model.h5')\n",
    "        self.instance_target_Critic_Model.load_weights(self.save_path+'target_critic_model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "instance_Agent = Agent('Humanoid-v2',learning_rate_Actor_Model=0.001,learning_rate_Critic_Model=0.003,reward_discount=0.99,save_path='../resource/project_robot/')\n",
    "if 0:\n",
    "    instance_Agent.load_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 520,
   "metadata": {},
   "outputs": [],
   "source": [
    "instance_Agent.save_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a74d275a78e94c9f92368e89f5d56215",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/120 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found a new best solution with reward 95.37232113917004\n",
      "Found a new best solution with reward 111.46399410832213\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x195.84 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 17ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 23ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IMAGEIO FFMPEG_WRITER WARNING: input image is not divisible by macro_block_size=16, resizing from (500, 500) to (512, 512) to ensure video compatibility with most codecs and players. To prevent resizing, make your input image divisible by the macro_block_size or set the macro_block_size to 1 (risking incompatibility).\n",
      "[swscaler @ 0x5928bc0] Warning: data is not aligned! This can lead to a speed loss\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Video saved to ../resource/project_robot/test_video.mp4.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "66.30819450690855"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAz0AAACSCAYAAABvyqTTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAASMUlEQVR4nO3dbYxc1X3H8d9vn2yvH1jAGIxtgkncpG7SYOJS0lRtwkNr07ROK0WFKA1CjaxI0JAoaeW2L6q8iNQXadpGRUFWoCFqCooINFZqQSglIo0KtSEpwRiKgQQvLNjGsR1s7N3Z+ffFXLeT3Tkzd+/u7Mxcfz/Slefec8/DzJyZ2b/Puec6IgQAAAAAZdXX6QYAAAAAQDsR9AAAAAAoNYIeAAAAAKVG0AMAAACg1Ah6AAAAAJQaQQ8AAACAUmtr0GN7k+1nbe+zva2ddaF32V5j+2Hbe23vsX1Ldvwc2w/afi779+xOtxXdyXa/7R/Y/na2T99BS7ZHbN9j+5ns++e99B3kYfvT2e/VU7bvsr2QvgN0t7YFPbb7Jd0qabOk9ZKut72+XfWhp1UkfSYiflHSFZJuyvrKNkkPRcQ6SQ9l+0Ajt0jaW7dP30Eefy/p/oh4h6R3q9aH6DtoyvYqSZ+UtDEi3impX9J1ou8AXa2dIz2XS9oXES9ExLikuyVtaWN96FERMRYRT2SPf6baHx6rVOsvd2an3SnpQx1pILqa7dWSfkfSV+oO03fQlO1lkn5D0u2SFBHjEXFE9B3kMyBpke0BScOSXhF9B+hq7Qx6VknaX7c/mh0DkmxfLGmDpMcknR8RY1ItMJK0ooNNQ/f6O0l/Jqlad4y+g1YukXRQ0j9mUyO/Ynux6DtoISJelvQFSS9JGpN0NCK+I/oO0NXaGfS4wbFoY33ocbaXSPqmpE9FxLFOtwfdz/YHJR2IiMc73Rb0nAFJl0n6ckRskHRcTEdCDtm1OlskrZV0oaTFtj/a2VYBaKWdQc+opDV1+6tVG/4FprE9qFrA8/WIuDc7/JrtlVn6SkkHOtU+dK33Sfo92z9WbQrtlbb/SfQdtDYqaTQiHsv271EtCKLvoJWrJb0YEQcjYkLSvZJ+TfQdoKu1M+jZJWmd7bW2h1S7yG9HG+tDj7Jt1ebV742IL9Yl7ZB0Q/b4Bknfmu+2obtFxJ9HxOqIuFi175h/j4iPir6DFiLiVUn7bb89O3SVpKdF30FrL0m6wvZw9vt1lWrXotJ3gC7miPbNOLN9rWrz7fsl3RERn29bZehZtn9d0vck/Uj/f13GX6h2Xc83JF2k2o/MhyPicEcaia5n+/2SPhsRH7R9rug7aMH2paotgDEk6QVJN6r2n4H0HTRl+3OS/lC11Ud/IOnjkpaIvgN0rbYGPQAAAADQaW29OSkAAAAAdBpBDwAAAIBSI+gBAAAAUGoEPQAAAABKjaAHAAAAQKm1PeixvbXddaCc6Dsoir6Doug7KIq+A3S3+Rjp4UsARdF3UBR9B0XRd1AUfQfoYkxvAwAAAFBqbbk56cCy4RhcMSJJqhw7oYFlw3NeB8qPvoOi6Dsoir6Doug7yGviwBFVjp1wp9uR129/YDgOHa5OO/7Ek6ceiIhNHWhSIQPtKHRwxYjWfoFRXgAAAKDei5/d3ukmzMjBw5P63v0XTDu+5MKXlnegOYW1JegBAAAA0PtCoYmYPtLTawh6AAAAADQUkiZE0AMAAACgpKoKnWSkBwAAAEBZRUgTc7/u2bwj6AEAAADQUMiaiJ5ZbC6JoAcAAABAQyFpvAS39iToAQAAANBQVdbJ6P2QofefAQAAAIC2CEkT0fsjPbmege1Ntp+1vc/2tnY3CgAAAEDn1a7pGZi29ZqWLbbdL+lWSddIGpW0y/aOiHi63Y0DAAAA0DkRZ870tssl7YuIFyTJ9t2Stkgi6AEAAABKLGSNnyFBzypJ++v2RyX9anuaAwAAAKBb1K7p6e90M2YtT9DTaGHuabcosr1V0lZJGjjvrFk2CwAAAECnnb6mp9fleQajktbU7a+W9MrUkyJiu6TtkrTobReW4L6tAAAAwJmttmT1YKebMWt5gp5dktbZXivpZUnXSfpIW1sFAAAAoOMifGZMb4uIiu2bJT0gqV/SHRGxp+0tAwAAANBRIZViIYNc9+mJiJ0R8QsR8daI+Hy7GwUAAACg86qyTlUHp215tLrXp2u+lKU/afuyurQ7bB+w/dRcPI/ev70qAAAAgLaoLWTQP21rpe5en5slrZd0ve31U07bLGldtm2V9OW6tK9K2jQHT0ESQQ8AAACAhNPX9Mw06FHdvT4jYlzS6Xt91tsi6WtR86ikEdsra/XGI5IOz9Xz6P0JegAAAADaImSdzDmdbYo89/psdM4qSWNFKmyGoAcAAABAQ01uTrrc9u66/e3ZLWxOy3Ovz1z3A50LBD0AAAAAGgpZlcZBz6GI2Ngka557fea6H+hc4JoeAAAAAA1FSBPVvmlbDv93r0/bQ6rd63PHlHN2SPpYtorbFZKORsScT22TGOkBAAAAkFBbsnrmIUPqXp+2P5Gl3yZpp6RrJe2TdELSjafz275L0vtVm0Y3KumvIuL2os+DoAcAAABAQnJ6W0sRsVO1wKb+2G11j0PSTYm81xeqNKEtQU/fT/u19J6lc1pmNLrMqY6bXPIUBSfxuVosX6u2NvOuT/4omVZtUvBA32STfOkXoK/Jk2yWbzbaUedsymyWt79Jx/rOdzekC22Sz9X0+zibvtP0M9Ck3Gb5mmlaZro71jR7S5p97gq+Ppdse7RYxmjx4rhgg1qVO9f1tVK0PW0wsPYtzU9o1tair0+zfO16r4o+j2qTD0izfEXLbOFfvn9futgmH+a+grPrm5XZyoDSf7RVlP7SKtrWiUiXOdw3lEx7o3qyabkLnF5F61RMJNN+9+N/0rTcQmbzeWzHZ7lomS0+581+J6uD6XL7Jhpn3H+wt64uqU1vKxb0dBNGegAAAAA0VJU1TtADAAAAoLTCqhD0AAAAACirkFRp0yUP84mgBwAAAEBDIamSb4nqrkbQAwAAAKChCK7pAQAAAFBijPQAAAAAKLWQNUnQAwAAAKCsuE8PAAAAgJJjpAcAAABAiUVIk1V3uhmz1jJss32H7QO2n5qPBgEAAADoDiFroto/bes1ecaqvippU5vbAQAAAKALVauetvWaltPbIuIR2xfPQ1sAAAAAdJHa9Dau6QEAAABQYr04sjPVnAU9trdK2ipJQ8Nnz1WxAAAAADokohyrt83ZM4iI7RGxMSI2DixcPFfFAgAAAOigqHra1muY3gYAAACgoVA5prflWbL6Lkn/Kenttkdt/3H7mwUAAACg40KKSU/bek2e1duun4+GAAAAAOg2vTmdbSqmtwEAAABoLETQAwAAAKDkgqAHAAAAQFll1/T0OoIeAAAAAGlMbwMAAABQWiG52ulGzB5BDwAAAIAES0xvAwAAAFBaIaa3AQAAACg3prcl9B8+rmX//GjDtFObfyWZb2JpfzJtZNdY0zqrixcl0/oO/TSZFpPpd9ED6fZMXHJBMm3gwLFk2ptvPTeZJklP/827kmkjj72cTKuOLEmmRV9fMs0Tk8m08RWLk2mSNHBiIl3uqXS5nkynTS5ZkEzrP3YqmRYL0u9V38lKMk2SfPSNdLlnpV/XdQNH0vmefj5d3y+9LZl28vzhZForC189nk6cjGRSdXgwmdb/k9eSaR5Of+aqy5o/j8rIwnS54+nPZGVpuq1vrEynTf7mhmRa33i6Pw683uQ1lVRt0l/7Rg8m0ybesSqZFn3p/00beq1JXx1MfwbGlzd/PwaOpz/LlSb9Y+j1E8m0Q+8ZSaaNPH8ymXZiUfGfpUXPv55MO3XR2cm0hf+T7ucTa9Lf2YNjR5Jpk+cuTaZJUt+PX02mnfrli5Jp/SfT/fXk8qFkmtPZNHQ0/f4PHk6/x5K05bc+kq7z+JvJtMqKs9KFNvkMDLx6JJl29D0r02VKWvZMOu+p89Pf9QvG0r/pPpHuy7Eg/X6MX5h+/m+el/7MSdLI7nTfGb/onGTagmNNPq8bl6XzHUl/Jy99Mf0dOXFW+vtRkoYOpdvjN8eTaZXl6feq/3g6nyL9O1g5K/17JknVofTfUcP7j6bzLW78GrjSexGE0y9fz0i/iwAAAADObKHaNT1Ttxxsb7L9rO19trc1SLftL2XpT9q+LG/emSLoAQAAAJDk6vStZR67X9KtkjZLWi/petvrp5y2WdK6bNsq6cszyDsjBD0AAAAAGnIUC3okXS5pX0S8EBHjku6WtGXKOVskfS1qHpU0YntlzrwzQtADAAAAIMmTnrblsErS/rr90exYnnPy5J0RVm8DAAAA0Fj65qTLbe+u298eEdvr9htFRlOXREidkyfvjBD0AAAAAEhrHPQcioiNTXKNSlpTt79a0is5zxnKkXdGmN4GAAAAIKngNT27JK2zvdb2kKTrJO2Ycs4OSR/LVnG7QtLRiBjLmXdGGOkBAAAA0Fh6elvzbBEV2zdLekBSv6Q7ImKP7U9k6bdJ2inpWkn7JJ2QdGOzvLN5GgQ9AAAAABqyigU9khQRO1ULbOqP3Vb3OCTdlDfvbBD0AAAAAGis4EhPt2l5TY/tNbYftr3X9h7bt8xHwwAAAAB0nienb70mz0hPRdJnIuIJ20slPW77wYh4us1tAwAAANBJodTqbT2l5UhPRIxFxBPZ459J2qtZ3hwIAAAAQG8ouHpbV5nRNT22L5a0QdJjDdK2StoqSQs1PBdtAwAAANBJ0ZvT2abKfZ8e20skfVPSpyLi2NT0iNgeERsjYuOgFsxlGwEAAAB0gCU5pm+9JtdIj+1B1QKer0fEve1tEgAAAIBu0YvT2aZqGfTYtqTbJe2NiC+2v0kAAAAAusKZsmS1pPdJ+iNJV9r+YbZd2+Z2AQAAAOgCZ8SS1RHxH6pN5wMAAABwJinJSM+MVm8DAAAAcOawCHoAAAAAlFlInuzB5dqmIOgBAAAAkMRIDwAAAIBSI+gBAAAAUFoOqa8HV2ubiqAHAAAAQJKrXNMDAAAAoKyiN+/LMxVBDwAAAICkMlzT44i5H65auHpNrL7503NeLgAAANDLRv/hb3VydL873Y68lpy9Ji79wC3Tjn//vj99PCI2dqBJhTDSAwAAAKAhR3BNDwAAAIByK8P0NoIeAAAAAI2F5AojPQAAAABKjOltAAAAAMormN4GAAAAoMQsyZOM9AAAAAAoqwh5sveHegh6AAAAACRxTQ8AAACA8gqmtwEAAAAouTJMb+trdYLthbb/y/Z/295j+3Pz0TAAAAAAneUIeXL6Nqsy7XNsP2j7uezfsxPnbbL9rO19trfVHf9wFpdUbW/MU2fLoEfSKUlXRsS7JV0qaZPtK/IUDgAAAKDHVavTt9nZJumhiFgn6aFs/+fY7pd0q6TNktZLut72+iz5KUl/IOmRvBW2DHqi5o1sdzDben9iHwAAAIDmQnKlOm2bpS2S7swe3ynpQw3OuVzSvoh4ISLGJd2d5VNE7I2IZ2dSYZ6RHtnut/1DSQckPRgRjzU4Z6vt3bZ3Tx4/PpM2AAAAAOhGEamRnuWn//bPtq0zKPX8iBirFR9jklY0OGeVpP11+6PZsUJyLWQQEZOSLrU9Iuk+2++MiKemnLNd0nZJWrh6DSNBAAAAQAkkruE5FBHJ62ls/5ukCxok/WXeahscKxxjzGj1tog4Yvu7kjapNpcOAAAAQFmFpAKrt0XE1ak026/ZXhkRY7ZXqjabbKpRSWvq9ldLemXGDcnkWb3tvGyER7YXSbpa0jNFKwQAAADQK0KanJy+zc4OSTdkj2+Q9K0G5+yStM72WttDkq7L8hWS55qelZIetv1kVvmDEfHtohUCAAAA6BHRlqDnryVdY/s5Sddk+7J9oe2dtWqjIulmSQ9I2ivpGxGxJzvv922PSnqvpH+1/UCrCltOb4uIJyVtKPZ8AAAAAPSsgtPbmhYZ8bqkqxocf0XStXX7OyXtbHDefZLum0mdM7qmBwAAAMCZJOZiZKfjCHoAAAAANBYi6AEAAABQZjHn09s6gaAHAAAAQGMhBSM9AAAAAEorQqpUOt2KWSPoAQAAAJAQjPQAAAAAKDEWMgAAAABQZhGh6kTvT29zRMx9ofZBST/JdpdLOjTnleBMQN9BUfQdFEXfQVH0HeT1log4r9ONyMv2/ar176kORcSm+W5PUW0Jen6uAnt3RGxsayUoJfoOiqLvoCj6Doqi7wDdra/TDQAAAACAdiLoAQAAAFBq8xH0bJ+HOlBO9B0URd9BUfQdFEXfAbpY26/pAQAAAIBOYnobAAAAgFIj6AEAAABQagQ9AAAAAEqNoAcAAABAqRH0AAAAACi1/wXP40C3yoASHAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1152x144 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x144 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x144 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#instance_Agent.explore_value_scale = 1\n",
    "#instance_Agent.instance_Experience_Buffer.buffer_counter = 0\n",
    "instance_Agent.force_explore = 0\n",
    "instance_Agent.explore(120)\n",
    "plt.plot(instance_Agent.history_episodic_reward)\n",
    "plt.show()\n",
    "plt.axhline(0,color='r')\n",
    "plt.plot(instance_Agent.history_training[0][100:],label='actor_loss')\n",
    "plt.plot(instance_Agent.history_training[1][100:],label='critic_loss')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "plt.matshow(instance_Agent.instance_Experience_Buffer.buffer_action[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].T)\n",
    "plt.colorbar()\n",
    "plt.show()\n",
    "plt.matshow(instance_Agent.instance_Experience_Buffer.buffer_reward[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].T)\n",
    "plt.colorbar()\n",
    "plt.matshow(instance_Agent.instance_Experience_Buffer.buffer_done[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].T)\n",
    "plt.colorbar()\n",
    "plt.matshow(instance_Agent.instance_Critic_Model([\n",
    "    instance_Agent.instance_Experience_Buffer.buffer_state[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].reshape(100,-1),\n",
    "    instance_Agent.instance_Experience_Buffer.buffer_action[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].reshape(100,-1)\n",
    "    ]).numpy().T)\n",
    "plt.colorbar()\n",
    "instance_Agent.test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x195.84 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 207ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 26ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 23ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 22ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 28ms/step\n",
      "1/1 [==============================] - 0s 24ms/step\n",
      "1/1 [==============================] - 0s 24ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 20ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 19ms/step\n",
      "1/1 [==============================] - 0s 21ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IMAGEIO FFMPEG_WRITER WARNING: input image is not divisible by macro_block_size=16, resizing from (500, 500) to (512, 512) to ensure video compatibility with most codecs and players. To prevent resizing, make your input image divisible by the macro_block_size or set the macro_block_size to 1 (risking incompatibility).\n",
      "[swscaler @ 0x5df1bc0] Warning: data is not aligned! This can lead to a speed loss\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Video saved to ../resource/project_robot/test_video.mp4.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "176.2042157530351"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x144 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x144 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x144 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(instance_Agent.history_episodic_reward)\n",
    "plt.show()\n",
    "plt.axhline(0,color='r')\n",
    "plt.plot(instance_Agent.history_training[0][100:],label='actor_loss')\n",
    "plt.plot(instance_Agent.history_training[1][100:],label='critic_loss')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "plt.matshow(instance_Agent.instance_Experience_Buffer.buffer_action[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].T)\n",
    "plt.colorbar()\n",
    "plt.show()\n",
    "plt.matshow(instance_Agent.instance_Experience_Buffer.buffer_reward[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].T)\n",
    "plt.colorbar()\n",
    "plt.matshow(instance_Agent.instance_Experience_Buffer.buffer_done[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].T)\n",
    "plt.colorbar()\n",
    "plt.matshow(instance_Agent.instance_Critic_Model([\n",
    "    instance_Agent.instance_Experience_Buffer.buffer_state[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].reshape(100,-1),\n",
    "    instance_Agent.instance_Experience_Buffer.buffer_action[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].reshape(100,-1)\n",
    "    ]).numpy().T)\n",
    "plt.colorbar()\n",
    "instance_Agent.test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7ff1c4efaef0>"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA00AAAB+CAYAAAD4BfqyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAATlElEQVR4nO3dcYxl5Xnf8e9vZnZ2dtcLLF6HALtOUErqIqdO6oXgJkaOic1GscCV7Mium+AqNVVTt24at8ataiScqK7SNG5VKzIlduPKDiHUbVYuZUtpaFNVRQsYgRdsscEYdk0S4zU1wbCzM/P0j3sWX8/cc2b2Dnfn3uH7kY5mznnPe8479773PfPc877vSVUhSZIkSRpsaqMLIEmSJEnjzKBJkiRJkjoYNEmSJElSB4MmSZIkSepg0CRJkiRJHQyaJEmSJKnDzEYXQJIkSdLmdtVP7ahvHl9csf2+B08crKr9G1Ck02LQJEmSJGmknj6+yD0H96zYvuX8P969AcU5bQZNkiRJkkaqKE7UyY0uxtAMmiRJkiSNVFGcrKWNLsbQDJokSZIkjVQBJzFokiRJkqSBlihe8E6TJEmSJA1WBSdro0sxPIMmSZIkSSNVhJOVjS7G0AyaJEmSJI1UAfNMbXQxhmbQJEmSJGmklggv1OSGHpNbckmSJEkToYCT5Z0mSZIkSRqoN6ZpckOPyS25JEmSpIlQZfc8SZIkSWpVhPkJDpomt2OhJEmSpInQG9M0vWJZiyT7k3wlyZEk1w9IvyLJ/UkWkrxjWdodSZ5J8oVl2/99kq8meaBZfrSrDJMb7kmSJEmaCMOOaUoyDXwCeAtwFDiU5EBVPdy32xPAe4EPDjjErwPbgb89IO0fVdVtaymHQZMkSZKkkepNOb5lmKyXAUeq6jGAJLcA1wAvBk1V9XiTtrQ8c1XdleRNw5y4n93zJEmSJI1UVYbtnnch8GTf+tFm20vh15I8mOQ3k2zt2tGgSZIkSdJIFTBfMysWYHeSe/uW685QkT4MvAa4FDgX+FDXznbPkyRJkjRSS4QTSwO75z1dVfs6sh4D9vat72m2rUtVPdX8eiLJpxk8HupF3mmSJEmSNFK9iSCG6p53CLg4yUVJZoF3AQfWW54k5zc/A7wd+FLX/gZNkiRJkkZq2DFNVbUAvB84CDwC3FpVh5PcmORqgCSXJjkKvBP4ZJLDp/In+SPg94ErkxxNclWT9NkkDwEPAbuBX+0qh93zJEmSJI1UEV4Y3D1v9bxVtwO3L9v2kb7fD9Hrtjco7xtbtr/5dMpg0CRJkiRppE493HZSGTRJkiRJGqkiLBg0SZIkSdJgVXByaXKnUzBokiRJkjRSvSnHJzf0mNySS5IkSZoQds+TJEmSpFa97nkGTZIkSZI00BJh3qBJkiRJklpUWDBokiRJkqTBClgoZ8+TJEmSpIEKWHDKcUmSJEkarMoxTZIkSZLUatLvNE1EyZPsT/KVJEeSXL/R5dF4SrI3yR8meTjJ4SQfaLafm+TOJI82P3dtdFk1npJMJ/liki806xcluadpe34vyexGl1HjJ8k5SW5L8uUkjyR5g+2O1iLJLzfXqy8l+d0kc7Y72qyKsLg0tWKZFGNf0iTTwCeAnwEuAd6d5JKNLZXG1ALwK1V1CXA58HebunI9cFdVXQzc1axLg3wAeKRv/V8Av1lVfwH4FvCLG1Iqjbt/DdxRVa8BXkevDtnuqFOSC4G/D+yrqtcC08C7sN3RJnXqOU3Ll0kx9kETcBlwpKoeq6p54Bbgmg0uk8ZQVT1VVfc3vz9L7x+XC+nVl99pdvsd4O0bUkCNtSR7gJ8Fbm7WA7wZuK3ZxbqjFZKcDVwB/DZAVc1X1TPY7mhtZoBtSWaA7cBT2O5o0/JO06hdCDzZt3602Sa1SvKDwI8B9wDnVdVTTdKfAOdtVLk01j4O/GNgqVl/JfBMVS0067Y9GuQi4BvAp5uunTcn2YHtjlZRVceAfwk8QS9Y+n/AfdjuaJOqgsWlrFgmxSQETdJpSfIK4D8C/6Cqvt2fVlVFbyyi9KIkbwP+rKru2+iyaOLMAH8F+K2q+jHgOZZ1xbPd0SDNOLdr6AXeFwA7gP0bWihphIoM3T1vtfkNklyR5P4kC0nesSztjiTPnBqv3Lf9tMYPTkLQdAzY27e+p9kmrZBkC72A6bNV9flm858mOb9JPx/4s40qn8bWTwBXJ3mcXhfgN9Mbp3JO020GbHs02FHgaFXd06zfRi+Ist3Ran4a+GpVfaOqTgKfp9cW2e5o01payoplNWuc3+AJ4L3A5wYc4teBnx+w/bTGD05C0HQIuLiJBmfpDZI8sMFl0hhqxqD8NvBIVf2rvqQDwLXN79cCf3Cmy6bxVlUfrqo9VfWD9NqY/1FV7wH+EDj1jZV1RytU1Z8ATyb5i82mK4GHsd3R6p4ALk+yvbl+nao7tjvalHrd84Ya07Tq/AZV9XhVPch3u9j3p90FPNu/bZhxy2P/nKaqWkjyfuAgvZllPlVVhze4WBpPP0Hvm4SHkjzQbPsnwMeAW5P8IvA14Oc2pniaQB8Cbknyq8AXaQb7S8v8PeCzzRd7jwF/k96XkrY7alVV9yS5Dbif3uyvXwRuAv4LtjvapNZyZ2mAQfMb/Pg6i3La45bHPmgCqKrbgds3uhwab1X1v4G2T+OVZ7IsmlxVdTdwd/P7Y/S+4ZJaVdUDwL4BSbY76lRVNwA3LNtsu6NNqSptd5Z2J7m3b/2mqrrpDBVrzSYiaJIkSZI02Wrwnaanq2rQF0+njGJ+g2/SjB9s7jatesxJGNMkSZIkaYIVw00EwQjmN2hmNT2t8YMGTZIkSZJGq6AWs2JZNVvvTtCp+Q0eAW6tqsNJbkxyNUCSS5McBd4JfDLJi/MfJPkj4PeBK5McTXJVk/Qh4B8mOUJvjFPn+EG750mSJEkasbR1z1vVoPkNquojfb8fotfFblDeN7ZsP63xgwZNkiRJkkarWsc0TYR1dc9Lcm6SO5M82vzc1bHvWc0tsX875LmuG76kejmz7mhY1h0Ny7qjYVhvtOlVVi4TYr1jmq4H7qqqi4G7mvU2HwX+1zrOZUOiYVl3NCzrjoZl3dEwrDfavIYc0zQu1ts9768BX28e3vd14AJ6g6pelORHgc8APwB8G/DBtJIkSdLLzQR3z1tv0LSX3kwTDwD/AXhlkuur6mN9+zwPvAD8T+ANwFuS/OWqerDrwLPT22rbzFkvrs9N7+TsrecVAFMdN8iq2tOyyhvVlbcjiamO43ads+N81XXMVSzNTneUp6M4HS/rUtchu1621f6MIe91dpV1edr0rl1s3bu3ALI03DFXLWdX/eh6gbpe1458XWnTU+1/5FRXWYCZrrwdf2TXUWenFoc65tzUyY6jwjTtZZ3ueKNnO16DLcve6FdfOMO+180VwELH+b765XNb0zrbFehuPxY7KmxXvq42cqnrA7uO9rOzFgybrSOx67VZTcffUktdjUTXZ/J7jzmXHZw99cpehpmOD3rX+breK4Dpjvd5qv2c1XGNqK7XpuPP6Kwfq116u9K7qmRXVe54abryDX7uZn/mIc/Z9Tb3/Sc2c/Yu5i7Yu7YP0zr6CnVe76aH/V+o4/PRkdZ1XdrScU2C7mth17VnseMFmEl7vq5ry0zXm0z39W6xo2K9avpEa9oXH5x/uqpe1XnicVLdn4Vxt2rQlOS/A98/IOmfAlvoBUuHgO8Au4EPJDlQVQ83+70F2Ab8JPAcvY/cx4E3DzjXdTS3puemd/JXv/+vDyxTbZ9rL/Bie2Vn62x7GsB8+z9pWWg/bs21H7em268y6SjrUscxV/PcRa9oTVvc0v7BXNzanvbCrva0rv9tl7a0pwEsbmtP6wziOl6ekzvaG6aZ5zvK0lWttq/yKe/6P2u240KyfaE1bXau/YWdnW3Pt3OuvYHdOdueBnDu1u+0pu2YmW9NO9ERVe+Ze6Y1bft0+zH/0tzXW9MAdk61v5mvnH6uNW3vTPvr+n3TO1rTvrXY/tr8jSve3ZrW1a7AKu3Zt/+8NSlzW9uP2ZGWE+2vOR3tHFtWuVx05e3SGTS0py39eft73HlMIB1/y9LzL7Sm1Yn2z8/UXPv7OLXrnPZjPtder2q+470CsmN7e9pZO1vTTl7QOvyYxbn2z/LJne1pSzPt14iuNOi+Lk0tdnxBNN+edmJn+wVky/Pt+eZ3dJe169qzsK0970zHOZ9/VXu+rn8wF7cN+UUFsNBxnVw6q/360nWtm97W3gbMbm1vB7dtba/n572ivQ2E7sDo1TuOt6Ydn29v63dvbT/nrpn2z+vuLc+2pgHMpf01eHapvf34O+c82pq2/YKvfa3zpGMnMEHd8ZZbNWiqqp9uS2u+WXs9cA7wU8D/aZLeB/xy8/sbgB8GjgM76X03ckWSNA+W6j/XTcBNwHfvKkmSJEmabMXm7p63yp2mk8Av0buD9AV6N66/AVx+aqeqek+S1wG/QG+yiAAL9B4i9fSyc33PnSZJkiRJm8Om7p63yp2mJ4HX0uuWdwh4ht5kEM8lubmq/laz6xS9bnzfAWbpBVuSJEmSXiYywXea1jvl+H8GjgIngM8D/4neLHqcCpiSzALnAfPA7wKnOqB+c53nliRJkjQJit64uOXLhFhv0PQx4FXAVuBtwG8ArwZOJLm52efn6I15ei3wfnp3mr68fDwT9MY0VdW+qto3O90xQ4AkSZKkiZKllcukWFfQVFXfBD5Mb1rxC/juRBD30nt+09XA5+hNST4P/Gnz858POl6S65Lcm+Te+cWOac4kSZIkTYzUZAdN631OE8CTwCP0ZsabBu4BHqI3zTjN9h9p0s5vzvl7SX6yqu7tP1D/7HlJvnHHEx/vn0pxN8smjlCL+ze6AGPHuqNhrbHu/MbIC6Ixt/J7vu/WnVF9B9h13K5a+9hLXRC9hLxe6Xv8SnfyD5yZUrx0spmnHF+DQ8Au4ErgWLN+oKoO9+3z4pMNktwNfHB5wLTc8od1Jbm3qva9BOXVy4x1R8Oy7mhY1h0Nw3qjTW3CH2673jFNVNUCvbFKB+ndcbq1qg4nubHpnidJkiTp5e5lPBEEAFV1e1X9cFX9UFX9WrPtI1V1YMC+b1rtLpMkSZKkzWXYMU1J9if5SpIjSa4fkH5FkvuTLCR5x7K0a5M82izX9m2/uznmA83yfV1leCm6550pN210ATSxrDsalnVHw7LuaBjWG21eQ3bPSzINfAJ4C71HHR1KcqCqHu7b7QngvcAHl+U9F7gB2NcrAfc1eb/V7PKetd7MeUnuNJ0JzSQR0mmz7mhY1h0Ny7qjYVhvtJmFoe80XQYcqarHqmoeuAW4pn+Hqnq8qh5kZYe/q4A7q+p4EyjdCewfpvwTEzRJkiRJmlDDTzl+Ib3Zuk852mx7KfJ+uuma98+SdE7tZ9AkSZIkaeSyuHIBdp96TmuzXHeGivOeqvoR4I3N8vNdO0/SmCZJkiRJk6homy3v6VWm2j8G7O1b39NsW4tjwJuW5b0boKqONT+fTfI5et0AP9N2IO80SZIkSRq5IbvnHQIuTnJRklngXcCKGbpbHATemmRXkl3AW4GDSWaS7AZIsgV4G/ClrgMZNEmSJEkarWrtntedbQ3PhE1yaZKjwDuBTyY53OQ9DnyUXuB1CLix2baVXvD0IPAAvTtS/66rHHbPkyRJkjRSAVLD5a2q24Hbl237SN/vh+h1vRuU91PAp5Ztew54/emUwaBJkiRJ0sgN85ymcWHQJEmSJGm0am3d8caVQZMkSZKkkfNOkyRJkiS1KYMmSZIkSWoVDJokSZIkqV1BFoecPm8MGDRJkiRJGjnvNEmSJElSB4MmSZIkSWqRgimnHJckSZKkdllyTJMkSZIkDebDbSVJkiSpm2OaJEmSJKmNU45LkiRJUrtUOaZJkiRJkrrYPU+SJEmS2hRkYXLvNE1tdAEkSZIkbX5ZqhXLmvIl+5N8JcmRJNcPSL8iyf1JFpK8Y1natUkebZZr+7a/PslDzTH/TZJ0lcGgSZIkSdJoVa973vJlNUmmgU8APwNcArw7ySXLdnsCeC/wuWV5zwVuAH4cuAy4IcmuJvm3gPcBFzfL/q5yGDRJkiRJGqnQmz1v+bIGlwFHquqxqpoHbgGu6d+hqh6vqgeB5WHYVcCdVXW8qr4F3AnsT3I+cFZV/d+qKuAzwNu7CmHQJEmSJGm0qsji0oplDS4EnuxbP9psW0/eC5vf13xMJ4KQJEmSNHItY5h2J7m3b/2mqrrpDBVpzQyaJEmSJI1W+8Ntn66qfR05jwF7+9b3NNvW4hjwpmV572627zmdY9o9T5IkSdLIDdk97xBwcZKLkswC7wIOrPGUB4G3JtnVTADxVuBgVT0FfDvJ5c2seb8A/EHXgQyaJEmSJI1UauUkEGuZCKKqFoD30wuAHgFurarDSW5McjVAkkuTHAXeCXwyyeEm73Hgo/QCr0PAjc02gF8CbgaOAH8M/NdVyj+5D5mSJEmSNP7O3nFBXf6a963Y/t/uv/G+VbrnjQXHNEmSJEkarYIsrKk73lgyaJIkSZI0WlWwZNAkSZIkSa3W+DDbsWTQJEmSJGm0CljbbHljyaBJkiRJ0ogVLC5udCGGZtAkSZIkabTKoEmSJEmS2tk9T5IkSZK6eKdJkiRJktoVBk2SJEmS1K7snidJkiRJrQrKO02SJEmS1KIKFhY2uhRDM2iSJEmSNGLlnSZJkiRJauVEEJIkSZLUrqpYOjm53fNSVRtdBkmSJEmbWJI7gN0Dkp6uqv1nujyny6BJkiRJkjpMbXQBJEmSJGmcGTRJkiRJUgeDJkmSJEnqYNAkSZIkSR0MmiRJkiSpw/8HlwENwWHDbBkAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1152x144 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x144 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x144 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in range(200):\n",
    "    instance_Agent.learn()\n",
    "plt.plot(instance_Agent.history_episodic_reward)\n",
    "plt.show()\n",
    "plt.axhline(0,color='r')\n",
    "plt.plot(instance_Agent.history_training[0][200:],label='actor_loss')\n",
    "plt.plot(instance_Agent.history_training[1][200:],label='critic_loss')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "plt.matshow(instance_Agent.instance_Experience_Buffer.buffer_reward[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].T)\n",
    "plt.colorbar()\n",
    "plt.matshow(instance_Agent.instance_Experience_Buffer.buffer_done[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].T)\n",
    "plt.colorbar()\n",
    "plt.matshow(instance_Agent.instance_Critic_Model([\n",
    "    instance_Agent.instance_Experience_Buffer.buffer_state[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].reshape(100,-1),\n",
    "    instance_Agent.instance_Experience_Buffer.buffer_action[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].reshape(100,-1)\n",
    "    ]).numpy().T)\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "IMAGEIO FFMPEG_WRITER WARNING: input image is not divisible by macro_block_size=16, resizing from (500, 500) to (512, 512) to ensure video compatibility with most codecs and players. To prevent resizing, make your input image divisible by the macro_block_size or set the macro_block_size to 1 (risking incompatibility).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Video saved to ../resource/project_robot/test_video.mp4.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "66.18425302860831"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "instance_Agent.test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 479,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x195.84 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7fbb97ea5e48>"
      ]
     },
     "execution_count": 479,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x144 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x144 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x144 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in range(2):\n",
    "    instance_Agent.learn()\n",
    "plt.axhline(0,color='r')\n",
    "plt.plot(instance_Agent.history_training[0][200:],label='actor_loss')\n",
    "plt.plot(instance_Agent.history_training[1][200:],label='critic_loss')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "plt.matshow(instance_Agent.instance_Experience_Buffer.buffer_action[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].T)\n",
    "plt.colorbar()\n",
    "plt.show()\n",
    "plt.matshow(instance_Agent.instance_Experience_Buffer.buffer_reward[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].T)\n",
    "plt.colorbar()\n",
    "plt.matshow(instance_Agent.instance_Experience_Buffer.buffer_done[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].T)\n",
    "plt.colorbar()\n",
    "plt.matshow(instance_Agent.instance_Critic_Model([\n",
    "    instance_Agent.instance_Experience_Buffer.buffer_state[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].reshape(100,-1),\n",
    "    instance_Agent.instance_Experience_Buffer.buffer_action[instance_Agent.instance_Experience_Buffer.buffer_counter-100:instance_Agent.instance_Experience_Buffer.buffer_counter].reshape(100,-1)\n",
    "    ]).numpy().T)\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.2"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
